\unset ECHO\i test/setup.sqlSELECT plan(411);
SET client_min_messages = warning;
CREATE TABLE public.sometab(    id      INT NOT NULL PRIMARY KEY,    name    TEXT DEFAULT '',    numb    NUMERIC(10, 2),    "myInt" NUMERIC(8));
CREATE INDEX idx_hey ON public.sometab(numb);
CREATE FUNCTION mkpart() RETURNS SETOF TEXT AS $$BEGIN    IF pg_version_num() >= 100000 THEN        EXECUTE $E$            CREATE TABLE public.apart (dt DATE NOT NULL) PARTITION BY RANGE (dt);
        $E$;
    ELSE    EXECUTE $E$        CREATE TABLE public.apart (dt DATE NOT NULL);
    $E$;
    END IF;
    RETURN;
END;
$$ LANGUAGE plpgsql;
SELECT * FROM mkpart();
CREATE VIEW public.someview AS SELECT * FROM public.sometab;
CREATE TYPE public.sometype AS (    id    INT,    name  TEXT);
CREATE SEQUENCE public.someseq;
CREATE SCHEMA someschema;
CREATE TABLE someschema.anothertab(    id INT PRIMARY KEY,    name    TEXT DEFAULT '');
CREATE DOMAIN someschema.us_postal_code AS TEXT CHECK(    VALUE ~ '^[[:digit:]]{5}$' OR VALUE ~ '^[[:digit:]]{5}-[[:digit:]]{4}$');
CREATE INDEX idx_name ON someschema.anothertab(name);
CREATE FUNCTION public.somefunction(int) RETURNS VOID LANGUAGE SQL AS '';
RESET client_min_messages;
SELECT * FROM check_test(    db_owner_is(current_database(), current_user, 'mumble'),	true,    'db_owner_is(db, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    db_owner_is(current_database(), current_user),	true,    'db_owner_is(db, user)',    'Database ' || quote_ident(current_database()) || ' should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    db_owner_is('__not__' || current_database(), current_user, 'mumble'),	false,    'db_owner_is(non-db, user)',    'mumble',    '    Database __not__' || current_database() || ' does not exist');
SELECT * FROM check_test(    db_owner_is(current_database(), '__not__' || current_user, 'mumble'),	false,    'db_owner_is(db, non-user)',    'mumble',    '        have: ' || current_user || '        want: __not__' || current_user);
SELECT * FROM check_test(    schema_owner_is(current_schema(), _get_schema_owner(current_schema()), 'mumble'),	true,    'schema_owner_is(schema, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    schema_owner_is(current_schema(), _get_schema_owner(current_schema())),	true,    'schema_owner_is(schema, user)',    'Schema ' || quote_ident(current_schema()) || ' should be owned by ' || _get_schema_owner(current_schema()),    '');
SELECT * FROM check_test(    schema_owner_is('__not__' || current_schema(), _get_schema_owner(current_schema()), 'mumble'),	false,    'schema_owner_is(non-schema, user)',    'mumble',    '    Schema __not__' || current_schema() || ' does not exist');
SELECT * FROM check_test(    schema_owner_is(current_schema(), '__not__' || _get_schema_owner(current_schema()), 'mumble'),	false,    'schema_owner_is(schema, non-user)',    'mumble',    '        have: ' || _get_schema_owner(current_schema()) || '        want: __not__' || _get_schema_owner(current_schema()));
SELECT * FROM check_test(    relation_owner_is('public', 'sometab', current_user, 'mumble'),	true,    'relation_owner_is(sch, tab, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('public', 'sometab', current_user),	true,    'relation_owner_is(sch, tab, user)',    'Relation public.sometab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__public', 'sometab', current_user, 'mumble'),	false,    'relation_owner_is(non-sch, tab, user)',    'mumble',    '    Relation __not__public.sometab does not exist');
SELECT * FROM check_test(    relation_owner_is('public', '__not__sometab', current_user, 'mumble'),	false,    'relation_owner_is(sch, non-tab, user)',    'mumble',    '    Relation public.__not__sometab does not exist');
SELECT * FROM check_test(    relation_owner_is('sometab', current_user, 'mumble'),	true,    'relation_owner_is(tab, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('sometab', current_user),	true,    'relation_owner_is(tab, user)',    'Relation sometab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__sometab', current_user, 'mumble'),	false,    'relation_owner_is(non-tab, user)',    'mumble',    '    Relation __not__sometab does not exist');
SELECT * FROM check_test(    relation_owner_is('public', 'apart', current_user, 'mumble'),	true,    'relation_owner_is(sch, part, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('public', 'apart', current_user),	true,    'relation_owner_is(sch, part, user)',    'Relation public.apart should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__public', 'apart', current_user, 'mumble'),	false,    'relation_owner_is(non-sch, part, user)',    'mumble',    '    Relation __not__public.apart does not exist');
SELECT * FROM check_test(    relation_owner_is('public', '__not__apart', current_user, 'mumble'),	false,    'relation_owner_is(sch, non-part, user)',    'mumble',    '    Relation public.__not__apart does not exist');
SELECT * FROM check_test(    relation_owner_is('apart', current_user, 'mumble'),	true,    'relation_owner_is(part, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('apart', current_user),	true,    'relation_owner_is(part, user)',    'Relation apart should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__apart', current_user, 'mumble'),	false,    'relation_owner_is(non-part, user)',    'mumble',    '    Relation __not__apart does not exist');
SELECT * FROM check_test(    relation_owner_is('public', 'someseq', current_user, 'mumble'),	true,    'relation_owner_is(sch, seq, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('public', 'someseq', current_user),	true,    'relation_owner_is(sch, seq, user)',    'Relation public.someseq should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__public', 'someseq', current_user, 'mumble'),	false,    'relation_owner_is(non-sch, seq, user)',    'mumble',    '    Relation __not__public.someseq does not exist');
SELECT * FROM check_test(    relation_owner_is('public', '__not__someseq', current_user, 'mumble'),	false,    'relation_owner_is(sch, non-seq, user)',    'mumble',    '    Relation public.__not__someseq does not exist');
SELECT * FROM check_test(    relation_owner_is('someseq', current_user, 'mumble'),	true,    'relation_owner_is(seq, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    relation_owner_is('someseq', current_user),	true,    'relation_owner_is(seq, user)',    'Relation someseq should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    relation_owner_is('__not__someseq', current_user, 'mumble'),	false,    'relation_owner_is(non-seq, user)',    'mumble',    '    Relation __not__someseq does not exist');
SELECT * FROM check_test(    table_owner_is('public', 'sometab', current_user, 'mumble'),	true,    'table_owner_is(sch, tab, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    table_owner_is('public', 'sometab', current_user),	true,    'table_owner_is(sch, tab, user)',    'Table public.sometab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    table_owner_is('__not__public', 'sometab', current_user, 'mumble'),	false,    'table_owner_is(non-sch, tab, user)',    'mumble',    '    Table __not__public.sometab does not exist');
SELECT * FROM check_test(    table_owner_is('public', '__not__sometab', current_user, 'mumble'),	false,    'table_owner_is(sch, non-tab, user)',    'mumble',    '    Table public.__not__sometab does not exist');
SELECT * FROM check_test(    table_owner_is('sometab', current_user, 'mumble'),	true,    'table_owner_is(tab, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    table_owner_is('sometab', current_user),	true,    'table_owner_is(tab, user)',    'Table sometab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    table_owner_is('__not__sometab', current_user, 'mumble'),	false,    'table_owner_is(non-tab, user)',    'mumble',    '    Table __not__sometab does not exist');
SELECT * FROM check_test(    table_owner_is('public', 'someseq', current_user, 'mumble'),	false,    'table_owner_is(sch, seq, user, desc)',    'mumble',    '    Table public.someseq does not exist');
SELECT * FROM check_test(    table_owner_is('someseq', current_user, 'mumble'),	false,    'table_owner_is(seq, user, desc)',    'mumble',    '    Table someseq does not exist');
SELECT * FROM check_test(    table_owner_is('public', 'apart', current_user, 'mumble'),	true,    'table_owner_is(sch, part, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    table_owner_is('apart', current_user, 'mumble'),	true,    'table_owner_is(part, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    view_owner_is('public', 'someview', current_user, 'mumble'),	true,    'view_owner_is(sch, view, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    view_owner_is('public', 'someview', current_user),	true,    'view_owner_is(sch, view, user)',    'View public.someview should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    view_owner_is('__not__public', 'someview', current_user, 'mumble'),	false,    'view_owner_is(non-sch, view, user)',    'mumble',    '    View __not__public.someview does not exist');
SELECT * FROM check_test(    view_owner_is('public', '__not__someview', current_user, 'mumble'),	false,    'view_owner_is(sch, non-view, user)',    'mumble',    '    View public.__not__someview does not exist');
SELECT * FROM check_test(    view_owner_is('someview', current_user, 'mumble'),	true,    'view_owner_is(view, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    view_owner_is('someview', current_user),	true,    'view_owner_is(view, user)',    'View someview should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    view_owner_is('__not__someview', current_user, 'mumble'),	false,    'view_owner_is(non-view, user)',    'mumble',    '    View __not__someview does not exist');
SELECT * FROM check_test(    view_owner_is('public', 'someseq', current_user, 'mumble'),	false,    'view_owner_is(sch, seq, user, desc)',    'mumble',    '    View public.someseq does not exist');
SELECT * FROM check_test(    view_owner_is('someseq', current_user, 'mumble'),	false,    'view_owner_is(seq, user, desc)',    'mumble',    '    View someseq does not exist');
SELECT * FROM check_test(    sequence_owner_is('public', 'someseq', current_user, 'mumble'),	true,    'sequence_owner_is(sch, sequence, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    sequence_owner_is('public', 'someseq', current_user),	true,    'sequence_owner_is(sch, sequence, user)',    'Sequence public.someseq should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    sequence_owner_is('__not__public', 'someseq', current_user, 'mumble'),	false,    'sequence_owner_is(non-sch, sequence, user)',    'mumble',    '    Sequence __not__public.someseq does not exist');
SELECT * FROM check_test(    sequence_owner_is('public', '__not__someseq', current_user, 'mumble'),	false,    'sequence_owner_is(sch, non-sequence, user)',    'mumble',    '    Sequence public.__not__someseq does not exist');
SELECT * FROM check_test(    sequence_owner_is('someseq', current_user, 'mumble'),	true,    'sequence_owner_is(sequence, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    sequence_owner_is('someseq', current_user),	true,    'sequence_owner_is(sequence, user)',    'Sequence someseq should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    sequence_owner_is('__not__someseq', current_user, 'mumble'),	false,    'sequence_owner_is(non-sequence, user)',    'mumble',    '    Sequence __not__someseq does not exist');
SELECT * FROM check_test(    sequence_owner_is('public', 'someview', current_user, 'mumble'),	false,    'sequence_owner_is(sch, view, user, desc)',    'mumble',    '    Sequence public.someview does not exist');
SELECT * FROM check_test(    sequence_owner_is('someview', current_user, 'mumble'),	false,    'sequence_owner_is(view, user, desc)',    'mumble',    '    Sequence someview does not exist');
SELECT * FROM check_test(    composite_owner_is('public', 'sometype', current_user, 'mumble'),	true,    'composite_owner_is(sch, composite, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    composite_owner_is('public', 'sometype', current_user),	true,    'composite_owner_is(sch, composite, user)',    'Composite type public.sometype should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    composite_owner_is('__not__public', 'sometype', current_user, 'mumble'),	false,    'composite_owner_is(non-sch, composite, user)',    'mumble',    '    Composite type __not__public.sometype does not exist');
SELECT * FROM check_test(    composite_owner_is('public', '__not__sometype', current_user, 'mumble'),	false,    'composite_owner_is(sch, non-composite, user)',    'mumble',    '    Composite type public.__not__sometype does not exist');
SELECT * FROM check_test(    composite_owner_is('sometype', current_user, 'mumble'),	true,    'composite_owner_is(composite, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    composite_owner_is('sometype', current_user),	true,    'composite_owner_is(composite, user)',    'Composite type sometype should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    composite_owner_is('__not__sometype', current_user, 'mumble'),	false,    'composite_owner_is(non-composite, user)',    'mumble',    '    Composite type __not__sometype does not exist');
SELECT * FROM check_test(    composite_owner_is('public', 'someview', current_user, 'mumble'),	false,    'composite_owner_is(sch, view, user, desc)',    'mumble',    '    Composite type public.someview does not exist');
SELECT * FROM check_test(    composite_owner_is('someview', current_user, 'mumble'),	false,    'composite_owner_is(view, user, desc)',    'mumble',    '    Composite type someview does not exist');
CREATE FUNCTION public.test_fdw() RETURNS SETOF TEXT AS $$DECLARE    tap record;
BEGIN    IF pg_version_num() >= 90100 THEN        EXECUTE $E$            CREATE FOREIGN DATA WRAPPER dummy;
            CREATE SERVER foo FOREIGN DATA WRAPPER dummy;
            CREATE FOREIGN TABLE public.my_fdw (id int) SERVER foo;
        $E$;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('public', 'my_fdw', current_user, 'mumble'),	        true,            'foreign_table_owner_is(sch, tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('public', 'my_fdw', current_user),	        true,            'foreign_table_owner_is(sch, tab, user)',            'Foreign table public.my_fdw should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('__not__public', 'my_fdw', current_user, 'mumble'),	        false,            'foreign_table_owner_is(non-sch, tab, user)',            'mumble',            '    Foreign table __not__public.my_fdw does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('public', '__not__my_fdw', current_user, 'mumble'),	        false,            'foreign_table_owner_is(sch, non-tab, user)',            'mumble',            '    Foreign table public.__not__my_fdw does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('my_fdw', current_user, 'mumble'),	        true,            'foreign_table_owner_is(tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('my_fdw', current_user),	        true,            'foreign_table_owner_is(tab, user)',            'Foreign table my_fdw should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('__not__my_fdw', current_user, 'mumble'),	        false,            'foreign_table_owner_is(non-tab, user)',            'mumble',            '    Foreign table __not__my_fdw does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
                FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('public', 'sometab', current_user, 'mumble'),	        false,            'foreign_table_owner_is(sch, tab, user, desc)',            'mumble',            '    Foreign table public.sometab does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            foreign_table_owner_is('sometab', current_user, 'mumble'),	        false,            'foreign_table_owner_is(tab, user, desc)',            'mumble',            '    Foreign table sometab does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
    ELSE                FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'foreign_table_owner_is(sch, tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'foreign_table_owner_is(sch, tab, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'foreign_table_owner_is(non-sch, tab, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'foreign_table_owner_is(sch, non-tab, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'foreign_table_owner_is(tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'foreign_table_owner_is(tab, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'foreign_table_owner_is(non-tab, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
                FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'foreign_table_owner_is(sch, tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'foreign_table_owner_is(tab, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
    END IF;
    RETURN;
END;
$$ LANGUAGE PLPGSQL;
SELECT * FROM public.test_fdw();
SELECT * FROM check_test(    function_owner_is('public', 'somefunction', ARRAY['integer'], current_user, 'mumble'),	true,    'function_owner_is(sch, function, args[integer], user, desc)',    'mumble',    '');
SELECT * FROM check_test(    function_owner_is('public', 'somefunction', ARRAY['integer'], current_user),	true,    'function_owner_is(sch, function, args[integer], user)',    'Function public.somefunction(integer) should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    function_owner_is('public', 'test_fdw', '{}'::NAME[], current_user, 'mumble'),	true,    'function_owner_is(sch, function, args[], user, desc)',    'mumble',    '');
SELECT * FROM check_test(    function_owner_is('public', 'test_fdw', '{}'::NAME[], current_user),	true,    'function_owner_is(sch, function, args[], user)',    'Function public.test_fdw() should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    function_owner_is('somefunction', ARRAY['integer'], current_user, 'mumble'),	true,    'function_owner_is(function, args[integer], user, desc)',    'mumble',    '');
SELECT * FROM check_test(    function_owner_is('somefunction', ARRAY['integer'], current_user),	true,    'function_owner_is(function, args[integer], user)',    'Function somefunction(integer) should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    function_owner_is('test_fdw', '{}'::NAME[], current_user, 'mumble'),	true,    'function_owner_is(function, args[], user, desc)',    'mumble',    '');
SELECT * FROM check_test(    function_owner_is('test_fdw', '{}'::NAME[], current_user),	true,    'function_owner_is(function, args[], user)',    'Function test_fdw() should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    function_owner_is('public', '__non__function', ARRAY['integer'], current_user, 'mumble'),	false,    'function_owner_is(sch, non-function, args[integer], user, desc)',    'mumble',    '    Function public.__non__function(integer) does not exist');
SELECT * FROM check_test(    function_owner_is('__non__public', 'afunction', ARRAY['integer'], current_user, 'mumble'),	false,    'function_owner_is(non-sch, function, args[integer], user, desc)',    'mumble',    '    Function __non__public.afunction(integer) does not exist');
SELECT * FROM check_test(    function_owner_is('__non__function', ARRAY['integer'], current_user, 'mumble'),	false,    'function_owner_is(non-function, args[integer], user, desc)',    'mumble',    '    Function __non__function(integer) does not exist');
SELECT * FROM check_test(    function_owner_is('public', 'somefunction', ARRAY['integer'], 'no one', 'mumble'),	false,    'function_owner_is(sch, function, args[integer], non-user, desc)',    'mumble',    '        have: ' || current_user || '        want: no one');
SELECT * FROM check_test(    function_owner_is('somefunction', ARRAY['integer'], 'no one', 'mumble'),	false,    'function_owner_is(function, args[integer], non-user, desc)',    'mumble',    '        have: ' || current_user || '        want: no one');
SELECT * FROM check_test(    tablespace_owner_is('pg_default', _get_tablespace_owner('pg_default'), 'mumble'),	true,    'tablespace_owner_is(tablespace, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    tablespace_owner_is('pg_default', _get_tablespace_owner('pg_default')),	true,    'tablespace_owner_is(tablespace, user)',    'Tablespace ' || quote_ident('pg_default') || ' should be owned by ' || _get_tablespace_owner('pg_default'),    '');
SELECT * FROM check_test(    tablespace_owner_is('__not__' || 'pg_default', _get_tablespace_owner('pg_default'), 'mumble'),	false,    'tablespace_owner_is(non-tablespace, user)',    'mumble',    '    Tablespace __not__' || 'pg_default' || ' does not exist');
SELECT * FROM check_test(    tablespace_owner_is('pg_default', '__not__' || _get_tablespace_owner('pg_default'), 'mumble'),	false,    'tablespace_owner_is(tablespace, non-user)',    'mumble',    '        have: ' || _get_tablespace_owner('pg_default') || '        want: __not__' || _get_tablespace_owner('pg_default'));
SELECT * FROM check_test(    index_owner_is('someschema', 'anothertab', 'idx_name', current_user, 'mumble'),	true,    'index_owner_is(schema, table, index, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    index_owner_is('someschema', 'anothertab', 'idx_name', current_user),	true,    'index_owner_is(schema, table, index, user)',    'Index idx_name ON someschema.anothertab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    index_owner_is('someschema', 'anothertab', 'idx_foo', current_user, 'mumble'),	false,    'index_owner_is(schema, table, non-index, user, desc)',    'mumble',    '    Index idx_foo ON someschema.anothertab not found');
SELECT * FROM check_test(    index_owner_is('someschema', 'nonesuch', 'idx_name', current_user, 'mumble'),	false,    'index_owner_is(schema, non-table, index, user, desc)',    'mumble',    '    Index idx_name ON someschema.nonesuch not found');
SELECT * FROM check_test(    index_owner_is('nonesuch', 'anothertab', 'idx_name', current_user, 'mumble'),	false,    'index_owner_is(non-schema, table, index, user, desc)',    'mumble',    '    Index idx_name ON nonesuch.anothertab not found');
SELECT * FROM check_test(    index_owner_is('someschema', 'anothertab', 'idx_name', '__noone', 'mumble'),	false,    'index_owner_is(schema, table, index, non-user, desc)',    'mumble',    '        have: ' || current_user || '        want: __noone');
SELECT * FROM check_test(    index_owner_is('anothertab', 'idx_name', current_user, 'mumble'),	false,    'index_owner_is(invisible-table, index, user, desc)',    'mumble',    '    Index idx_name ON anothertab not found');
SELECT * FROM check_test(    index_owner_is('sometab', 'idx_hey', current_user, 'mumble'),	true,    'index_owner_is(table, index, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    index_owner_is('sometab', 'idx_hey', current_user),	true,    'index_owner_is(table, index, user)',    'Index idx_hey ON sometab should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    index_owner_is('notab', 'idx_hey', current_user, 'mumble'),	false,    'index_owner_is(non-table, index, user)',    'mumble',    '    Index idx_hey ON notab not found');
SELECT * FROM check_test(    index_owner_is('sometab', 'idx_foo', current_user, 'mumble'),	false,    'index_owner_is(table, non-index, user)',    'mumble',    '    Index idx_foo ON sometab not found');
SELECT * FROM check_test(    index_owner_is('sometab', 'idx_hey', '__no-one', 'mumble'),	false,    'index_owner_is(table, index, non-user)',    'mumble',    '        have: ' || current_user || '        want: __no-one');
CREATE FUNCTION test_lang() RETURNS SETOF TEXT AS $$DECLARE    tap record;
BEGIN    IF pg_version_num() >= 80300 THEN        FOR tap IN SELECT * FROM check_test(            language_owner_is('plpgsql', _get_language_owner('plpgsql'), 'mumble'),	        true,            'language_owner_is(language, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            language_owner_is('plpgsql', _get_language_owner('plpgsql')),	        true,            'language_owner_is(language, user)',            'Language ' || quote_ident('plpgsql') || ' should be owned by ' || _get_language_owner('plpgsql'),            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            language_owner_is('__not__plpgsql', _get_language_owner('plpgsql'), 'mumble'),	        false,            'language_owner_is(non-language, user)',            'mumble',            '    Language __not__plpgsql does not exist'        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            language_owner_is('plpgsql', '__not__' || _get_language_owner('plpgsql'), 'mumble'),	        false,            'language_owner_is(language, non-user)',            'mumble',            '        have: ' || _get_language_owner('plpgsql') || '        want: __not__' || _get_language_owner('plpgsql')        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
    ELSE                FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'language_owner_is(language, user, desc)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            pass('mumble'),	        true,            'language_owner_is(language, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'language_owner_is(non-language, user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
        FOR tap IN SELECT * FROM check_test(            fail('mumble'),	        false,            'language_owner_is(language, non-user)',            'mumble',            ''        ) AS b LOOP RETURN NEXT tap.b;
 END LOOP;
 END LOOP;
    END IF;
END;
$$ LANGUAGE PLPGSQL;
SELECT * FROM test_lang();
SELECT * FROM check_test(    opclass_owner_is(        'pg_catalog', 'int4_ops',        _get_opclass_owner('pg_catalog', 'int4_ops'),        'mumble'    ),	true,    'opclass_owner_is(schema, opclass, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    opclass_owner_is(        'pg_catalog', 'int4_ops',        _get_opclass_owner('pg_catalog', 'int4_ops')    ),	true,    'opclass_owner_is(schema, opclass, user)',    'Operator class pg_catalog.int4_ops should be owned by ' || _get_opclass_owner('pg_catalog', 'int4_ops'),    '');
SELECT * FROM check_test(    opclass_owner_is(        'not_pg_catalog', 'int4_ops',        _get_opclass_owner('pg_catalog', 'int4_ops'),        'mumble'    ),	false,    'opclass_owner_is(non-schema, opclass, user, desc)',    'mumble',    '    Operator class not_pg_catalog.int4_ops not found');
SELECT * FROM check_test(    opclass_owner_is(        'pg_catalog', 'int4_nots',        _get_opclass_owner('pg_catalog', 'int4_ops'),        'mumble'    ),	false,    'opclass_owner_is(schema, not-opclass, user, desc)',    'mumble',    '    Operator class pg_catalog.int4_nots not found');
SELECT * FROM check_test(    opclass_owner_is(        'pg_catalog', 'int4_ops', '__no-one', 'mumble'    ),	false,    'opclass_owner_is(schema, opclass, non-user, desc)',    'mumble',    '        have: ' || _get_opclass_owner('pg_catalog', 'int4_ops') || '        want: __no-one');
SELECT * FROM check_test(    opclass_owner_is('int4_ops', _get_opclass_owner('int4_ops'), 'mumble'),	true,    'opclass_owner_is(opclass, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    opclass_owner_is('int4_ops', _get_opclass_owner('int4_ops')),	true,    'opclass_owner_is(opclass, user)',    'Operator class int4_ops should be owned by ' || _get_opclass_owner('int4_ops'),    '');
SELECT * FROM check_test(    opclass_owner_is('int4_nots', _get_opclass_owner('int4_ops'), 'mumble'),	false,    'opclass_owner_is(non-opclass, user, desc)',    'mumble',    '    Operator class int4_nots not found');
SELECT * FROM check_test(    opclass_owner_is('int4_ops', '__no-one', 'mumble'),	false,    'opclass_owner_is(opclass, non-user, desc)',    'mumble',    '        have: ' || _get_opclass_owner('int4_ops') || '        want: __no-one');
SELECT * FROM check_test(    type_owner_is('someschema', 'us_postal_code', current_user, 'mumble'),	true,    'type_owner_is(schema, type, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    type_owner_is('someschema', 'us_postal_code', current_user),	true,    'type_owner_is(schema, type, user)',    'Type someschema.us_postal_code should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    type_owner_is('	false,    'type_owner_is(non-schema, type, user, desc)',    'mumble',    '    Type ");
SELECT * FROM check_test(    type_owner_is('someschema', 'uk_postal_code', current_user, 'mumble'),	false,    'type_owner_is(schema, non-type, user, desc)',    'mumble',    '    Type someschema.uk_postal_code not found');
SELECT * FROM check_test(    type_owner_is('someschema', 'us_postal_code', '__no-one', 'mumble'),	false,    'type_owner_is(schema, type, non-user, desc)',    'mumble',    '        have: ' || current_user || '        want: __no-one');
SELECT * FROM check_test(    type_owner_is('us_postal_code', current_user, 'mumble'),	false,    'type_owner_is( invisible-type, user, desc)',    'mumble',    '    Type us_postal_code not found');
SELECT * FROM check_test(    type_owner_is('sometype', current_user, 'mumble'),	true,    'type_owner_is(type, user, desc)',    'mumble',    '');
SELECT * FROM check_test(    type_owner_is('sometype', current_user),	true,    'type_owner_is(type, user)',    'Type sometype should be owned by ' || quote_ident(current_user),    '');
SELECT * FROM check_test(    type_owner_is('__notype', current_user, 'mumble'),	false,    'type_owner_is(non-type, user, desc)',    'mumble',    '    Type __notype not found');
SELECT * FROM check_test(    type_owner_is('sometype', '__no-one', 'mumble'),	false,    'type_owner_is(type, non-user, desc)',    'mumble',    '        have: ' || current_user || '        want: __no-one');
CREATE FUNCTION test_materialized_view_owner_is() RETURNS SETOF TEXT AS $$DECLARE    tap record;
BEGIN    IF pg_version_num() >= 93000 THEN        EXECUTE $E$            CREATE MATERIALIZED VIEW public.somemview AS SELECT * FROM public.sometab;
        $E$;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('public', 'somemview', current_user, 'mumble'),            true,            'materialized_view_owner_is(sch, materialized_view, user, desc)',            'mumble',            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('public', 'somemview', current_user),            true,            'materialized_view_owner_is(sch, materialized_view, user)',            'Materialized view public.somemview should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('__not__public', 'somemview', current_user, 'mumble'),            false,            'materialized_view_owner_is(non-sch, materialized_view, user)',            'mumble',            '    Materialized view __not__public.somemview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('public', '__not__somemview', current_user, 'mumble'),            false,            'materialized_view_owner_is(sch, non-materialized_view, user)',            'mumble',            '    Materialized view public.__not__somemview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('somemview', current_user, 'mumble'),            true,            'materialized_view_owner_is(materialized_view, user, desc)',            'mumble',            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('somemview', current_user),            true,            'materialized_view_owner_is(view, user)',            'Materialized view somemview should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('__not__somemview', current_user, 'mumble'),            false,            'materialized_view_owner_is(non-materialized_view, user)',            'mumble',            '    Materialized view __not__somemview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
                FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('public', 'someseq', current_user, 'mumble'),            false,            'materialized_view_owner_is(sch, seq, user, desc)',            'mumble',            '    Materialized view public.someseq does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            materialized_view_owner_is('someseq', current_user, 'mumble'),            false,            'materialized_view_owner_is(seq, user, desc)',            'mumble',            '    Materialized view someseq does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
    else    FOR tap IN SELECT * FROM check_test(            view_owner_is('public', 'someview', current_user, 'mumble'),            true,            'materialized_view_owner_is(sch, materialized_view, user, desc)',            'mumble',            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('public', 'someview', current_user),            true,            'materialized_view_owner_is(sch, materialized_view, user)',            'View public.someview should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('__not__public', 'someview', current_user, 'mumble'),            false,            'materialized_view_owner_is(non-sch, materialized_view, user)',            'mumble',            '    View __not__public.someview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('public', '__not__someview', current_user, 'mumble'),            false,            'materialized_view_owner_is(sch, non-materialized_view, user)',            'mumble',            '    View public.__not__someview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('someview', current_user, 'mumble'),            true,            'materialized_view_owner_is(materialized_view, user, desc)',            'mumble',            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('someview', current_user),            true,            'materialized_view_owner_is(view, user)',            'View someview should be owned by ' || quote_ident(current_user),            ''        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('__not__someview', current_user, 'mumble'),            false,            'materialized_view_owner_is(non-materialized_view, user)',            'mumble',            '    View __not__someview does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
                FOR tap IN SELECT * FROM check_test(            view_owner_is('public', 'someseq', current_user, 'mumble'),            false,            'materialized_view_owner_is(sch, seq, user, desc)',            'mumble',            '    View public.someseq does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
        FOR tap IN SELECT * FROM check_test(            view_owner_is('someseq', current_user, 'mumble'),            false,            'materialized_view_owner_is(seq, user, desc)',            'mumble',            '    View someseq does not exist'        ) AS b LOOP                    RETURN NEXT tap.b;
                END LOOP;
    end if;
    return;
end;
 $$language PLPGSQL;
 $$language PLPGSQL;
SELECT * from test_materialized_view_owner_is();
SELECT * FROM finish();
ROLLBACK;
